import { Injectable } from '@angular/core';
import * as acorn from 'acorn';

@Injectable({
  providedIn: 'root',
})
export class CodeParserService {
  /**
   * 解析函数代码，提取函数名和参数
   * @param funcCode 函数代码字符串
   * @returns 包含函数名和参数的对象
   */
  parseFunction(funcCode: string): {
    funcName: string | null;
    params: string[];
  } {
    try {
      const ast = acorn.parse(funcCode, { ecmaVersion: 2020 });

      let funcName: string | null = null;
      let params: string[] = [];

      const traverse = (node: any) => {
        if (node.type === 'FunctionDeclaration') {
          funcName = node.id.name; // 获取函数名
          params = node.params.map((param: any) => param.name); // 获取参数名
        } else if (node.type === 'VariableDeclaration') {
          // 解析箭头函数 const add = (a, b) => { return a + b; }
          const declaration = node.declarations[0];
          if (
            declaration.init &&
            (declaration.init.type === 'ArrowFunctionExpression' ||
              declaration.init.type === 'FunctionExpression')
          ) {
            funcName = declaration.id.name; // 变量名作为函数名
            params = declaration.init.params.map((param: any) => param.name);
          }
        }

        for (const key in node) {
          if (typeof node[key] === 'object' && node[key] !== null) {
            traverse(node[key]); // 递归遍历 AST
          }
        }
      };

      traverse(ast);

      if (!funcName) {
        console.warn('无法解析函数名');
      }

      return { funcName, params };
    } catch (e) {
      console.error('解析函数失败:', e);
      return { funcName: null, params: [] };
    }
  }

  /**
   * 检查函数是否有返回值
   * @param funcCode 函数代码字符串
   * @returns 是否有返回值
   */
  hasReturnValue(funcCode: string): boolean {
    try {
      const ast = acorn.parse(funcCode, { ecmaVersion: 2020 });

      let hasReturn = false;

      const traverse = (node: any) => {
        if (node.type === 'ReturnStatement') {
          if (node.argument !== null) {
            hasReturn = true; // 只有 `return` 语句的 `argument` 不是 `null`，才算有返回值
          }
        }

        for (const key in node) {
          if (typeof node[key] === 'object' && node[key] !== null) {
            traverse(node[key]); // 递归遍历 AST
          }
        }
      };

      traverse(ast);
      return hasReturn;
    } catch (e) {
      console.error('解析函数出错:', e);
      return false; // 解析失败，默认当作无返回值
    }
  }
}
